Towards a Generic Interface to Integrate CLP and Tabled Execution (Extended Abstract)

Logic programming systems featuring Constraint Logic Programming (Jaffar and Ma-her 1994) and tabled execution (Tamaki and Sato 1986; Warren 1992) have been shown to increase the declarativeness and efficiency of Prolog, while at the same time making it possible to write very expressive programs. Previous implementations fully integrating both capabilities (i.e., forcing suspension, answer subsumption, etc. where it is necessary in order to avoid recomputation and terminate whenever possible) did not have a simple, well-documented, easy-to-understand interface which made it possible to integrate arbitrary CLP solvers into existing tabling systems. This clearly hinders a more widespread usage of this combination. In our work, we examine the requirements that a constraint solver must fulfill to be easily interfaced with a tabling system. We propose a minimal set of operations which the constraint solver has to provide to the tabling engine. These operations are based in only four objects (Vars, Dom, ProjStore and Store). Vars is a list with the constrained variables of a call. Dom and ProjStore are the representation of the projection of the constraint store of a call. Store is the representation of the constraint store of a generator and is used by the external constraint solver to reinstall it when the generator is complete. The two main operations to be provided by the solver are: (i) entailment, entail(+Vars A , +Dom A , +Dom B , +ProjStore B), which checks if the call/answer constraint store (Vars A and Dom A) is entailed by the previous call/answer constraint store (Dom B and ProjStore B) and (ii) projection, executed in two steps: project_domain(+Vars,-Dom), that pre-computes an object (Dom) used during the en-tailment, and project_gen_store(+Vars, +Dom,-ProjStore), which is executed when the entailment fails. The compiler performs a shallow program transformation adding tabled_call/1 to control the tabled execution and new_answer/0 to collect the answers. These two predicates invoke the operations of the interface during tabled execution. Fig. 1 contains a Prolog version of tabled_call/1 which specifies its implementation and the control flow of the execution. This specification shows that when a new call is entailed by a previous generator, its execution is suspended, unlike in usual tabling, where suspension happens only when variant calls are found. We validate experimentally our design with three use cases. First we re-engineer a